const User = require('../models/user');
const { generateToken } = require('../utils/jwt');
const axios = require('axios');

// 用户注册
const register = async (req, res) => {
  try {
    const { username, password, email } = req.body;

    // 验证输入
    if (!username || !password) {
      return res.status(400).json({
        success: false,
        message: '用户名和密码不能为空'
      });
    }

    // 检查用户名是否已存在
    const existingUser = await User.findByUsername(username);
    if (existingUser) {
      return res.status(400).json({
        success: false,
        message: '用户名已被占用'
      });
    }

    // 检查邮箱是否已存在
    if (email) {
      const emailExists = await User.findByEmail(email);
      if (emailExists) {
        return res.status(400).json({
          success: false,
          message: '电子邮件已被注册'
        });
      }
    }

    // 创建新用户
    const userId = await User.create({
      username,
      password,
      email,
      role: 'user'
    });

    // 获取新创建的用户
    const newUser = await User.findById(userId);

    // 生成JWT令牌
    const token = generateToken({
      id: newUser.id,
      username: newUser.username,
      role: newUser.role
    });

    // 返回用户信息和令牌
    res.status(201).json({
      success: true,
      message: '注册成功',
      data: {
        user: {
          id: newUser.id,
          username: newUser.username,
          email: newUser.email,
          role: newUser.role
        },
        token
      }
    });
  } catch (error) {
    console.error('注册错误：', error);
    res.status(500).json({
      success: false,
      message: '服务器内部错误'
    });
  }
};

// 用户登录
const login = async (req, res) => {
  try {
    const { username, password } = req.body;

    // 验证输入
    if (!username || !password) {
      return res.status(400).json({
        success: false,
        message: '用户名和密码不能为空'
      });
    }

    // 检查用户是否存在
    const user = await User.findByUsername(username);
    if (!user) {
      return res.status(401).json({
        success: false,
        message: '用户名或密码不正确'
      });
    }

    // 验证密码
    const isPasswordValid = await User.verifyPassword(password, user.password);
    if (!isPasswordValid) {
      return res.status(401).json({
        success: false,
        message: '用户名或密码不正确'
      });
    }

    // 生成JWT令牌
    const token = generateToken({
      id: user.id,
      username: user.username,
      role: user.role
    });

    // 初始化第三方access_token变量
    let accessToken = null;

    try {
      // 请求第三方授权API
      console.log('开始请求第三方授权API...');
      
      const thirdPartyResponse = await axios.post('http://47.110.53.42:9999/v3/Authorizations', 
        { 
          uname: "15004671972", 
          pwd: "123456"
        },
        {
          headers: {
            'Content-Type': 'application/json'
          }
        }
      );
      
      console.log('第三方授权API响应状态:', thirdPartyResponse.status);
      console.log('第三方授权API响应数据:', JSON.stringify(thirdPartyResponse.data));
      
      if (thirdPartyResponse.data && thirdPartyResponse.data.data && thirdPartyResponse.data.data.access_token) {
        // 保存access_token到用户记录
        accessToken = thirdPartyResponse.data.data.access_token;
        console.log('获取到的access_token:', accessToken);
        
        const updateResult = await User.update(user.id, { access_token: accessToken });
        console.log('更新用户access_token结果:', updateResult);
        
        console.log(`用户 ${username} 的access_token已更新`);
      } else {
        console.warn('获取第三方access_token失败, 响应数据结构不符合预期:', JSON.stringify(thirdPartyResponse.data));
      }
    } catch (thirdPartyError) {
      // 记录错误但不影响登录流程
      console.error('第三方授权请求失败:', thirdPartyError.message);
      console.error('错误详情:', thirdPartyError.response ? JSON.stringify(thirdPartyError.response.data) : '无响应数据');
    }

    // 返回用户信息和令牌，包括access_token
    res.status(200).json({
      success: true,
      message: '登录成功',
      data: {
        user: {
          id: user.id,
          username: user.username,
          email: user.email,
          role: user.role
        },
        token,
        access_token: accessToken  // 使用之前初始化的变量
      }
    });

    if (accessToken) {
      uni.setStorageSync('access_token', accessToken);
      console.log('第三方access_token已存储');
    }
  } catch (error) {
    console.error('登录错误：', error);
    res.status(500).json({
      success: false,
      message: '服务器内部错误'
    });
  }
};

// 获取当前用户信息
const getCurrentUser = async (req, res) => {
  try {
    const user = await User.findById(req.user.id);
    if (!user) {
      return res.status(404).json({
        success: false,
        message: '用户不存在'
      });
    }

    res.status(200).json({
      success: true,
      data: {
        user: {
          id: user.id,
          username: user.username,
          email: user.email,
          role: user.role
        }
      }
    });
  } catch (error) {
    console.error('获取用户信息错误：', error);
    res.status(500).json({
      success: false,
      message: '服务器内部错误'
    });
  }
};

// 获取当前用户的access_token
const getAccessToken = async (req, res) => {
  try {
    const user = await User.findById(req.user.id);
    if (!user) {
      return res.status(404).json({
        success: false,
        message: '用户不存在'
      });
    }

    if (!user.access_token) {
      return res.status(404).json({
        success: false,
        message: '未找到access_token，请先登录'
      });
    }

    res.status(200).json({
      success: true,
      data: {
        access_token: user.access_token
      }
    });
  } catch (error) {
    console.error('获取access_token错误：', error);
    res.status(500).json({
      success: false,
      message: '服务器内部错误'
    });
  }
};

module.exports = {
  register,
  login,
  getCurrentUser,
  getAccessToken
}; 